home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 101 / CD-ROM 101.iso / compl / maya5ple / Install_MayaPLE5_English.exe / Maya / Data1.cab / Maya_phong_postlighting_frag < prev    next >
Encoding:
Text File  |  2003-07-17  |  7.5 KB  |  231 lines
  1. // phong_fragment.cg
  2. //
  3. // This file cannot be directly compiled through CG... it first must be
  4. // parsed to insert channel-specific instructions.
  5. //
  6. // For example:
  7. // cgc.exe "$(InputPath)" -profile fp30 -o $(InputName).fp -DSPOT_LIGHT -DTRANSP_IN_TRANSP_RGB -DPROJ_LIGHT_TEXTURE
  8.  
  9. struct vert2frag
  10. {
  11.     float4 hPosition            : POSITION;
  12.  
  13. #if defined(BUMP_MAP)
  14.     float3 wBinormal            : TEXCOORD0;
  15.     float3 wTangent                : TEXCOORD1;
  16.     float4 bumpTexUv            : TEXCOORD2;
  17. #else
  18.     float3 wNormal                : TEXCOORD0;
  19. #endif // BUMP_MAP
  20.     
  21.     float4 transpTexUv            : TEXCOORD3;
  22.     float4 incanTexUv            : TEXCOORD4;
  23.     float4 reflectivityTexUv    : TEXCOORD5;
  24.     float4 wPosition            : TEXCOORD6;
  25. };
  26.  
  27. float4 main(vert2frag        IN,
  28.             uniform float4  wEyePosition,
  29.             uniform float    normalMultiplier,
  30.  
  31. #if defined(BUMP_MAP)
  32.             uniform sampler2D bumpTex,
  33.             uniform float4    bumpTexMatrix0,
  34.             uniform float4    bumpTexMatrix1,
  35. #endif // BUMP_MAP
  36.  
  37.             //[claforte] May one day be used to mimic software.
  38.             //uniform sampler2D specTex,
  39.             //uniform float4    specTexMatrix0,
  40.             //uniform float4    specTexMatrix1,
  41.             
  42.             uniform sampler2D transpTex,
  43.             uniform float4    transpTexMatrix0,
  44.             uniform float4    transpTexMatrix1,
  45.  
  46.             uniform sampler2D incanTex,
  47.             uniform float4    incanTexMatrix0,
  48.             uniform float4    incanTexMatrix1,
  49.  
  50. #if defined(REFLECT_CUBE_LOOKUP) || defined(REFRACT_CUBE_LOOKUP)
  51.             uniform float3 worldToCubeRotationMatrix0,
  52.             uniform float3 worldToCubeRotationMatrix1,
  53.             uniform float3 worldToCubeRotationMatrix2,
  54.             uniform samplerCUBE reflectedColTex,
  55. #endif // (REFLECT_CUBE_LOOKUP) || (REFRACT_CUBE_LOOKUP)
  56.  
  57. #if defined(REFLECT_SPHERE_LOOKUP)
  58.             uniform sampler2D reflectedColTex,
  59. #endif
  60.  
  61. #if defined (REFRACT_CUBE_LOOKUP)
  62.             // Refractive indices for red, green, blue.
  63.             uniform float3 refractiveIndices,
  64. #endif            
  65.  
  66.             uniform sampler2D reflectivityTex,
  67.             uniform float4    reflectivityTexMatrix0,
  68.             uniform float4    reflectivityTexMatrix1) : COLOR
  69. { 
  70.     // Calculate view direction in world space,
  71.     // from point to eye.
  72.     //
  73.     float3 wViewDir = normalize(wEyePosition.xyz - IN.wPosition.xyz);
  74.  
  75. #if defined(BUMP_MAP)
  76.     // Compute an orthonomal basis to transform from tangent space
  77.     // to world space, and vice-versa.
  78.     //
  79.     float3 wTangent = normalize(IN.wTangent);
  80.     float3 wNormal = normalize(cross(wTangent, IN.wBinormal));
  81.     float3 wBinormal = cross(wNormal, wTangent);
  82.  
  83.     // Translate and scale bump texture coordinates, by multiplying
  84.     // the uvs by the bump texture matrix.
  85.     //
  86.     float2 placedBumpTexUv;
  87.     float4 bumpTexUv = float4(IN.bumpTexUv.xy, 0.0, 1.0);
  88.     placedBumpTexUv.x = dot(bumpTexMatrix0, bumpTexUv);
  89.     placedBumpTexUv.y = dot(bumpTexMatrix1, bumpTexUv);
  90.  
  91.     // Fetch the bumped normal (in tangent space) from the bump texture.
  92.     // The (... * 2 - 1) at the end is used to unpack the normal components,
  93.     // from the [0,1] to [-1, -1] range.
  94.     //
  95.     float3 tBumpedNormal = normalize(f3tex2D(bumpTex, placedBumpTexUv) * 2 - 1);
  96.  
  97.     // Compute the world-space bumped normal.
  98.     //
  99.     float3 wBumpedNormal = normalMultiplier * tBumpedNormal.x * wTangent + 
  100.                            normalMultiplier * tBumpedNormal.y * wBinormal + 
  101.                            tBumpedNormal.z * wNormal;
  102. #else  // !defined(BUMP_MAP)
  103.     float3 wNormal = normalize(IN.wNormal);
  104.     float3 wBumpedNormal = wNormal;
  105. #endif // BUMP_MAP
  106.  
  107.  
  108.     // To support transparency and back-face lighting,
  109.     // allow normal inversion.
  110.  
  111.     wNormal = normalMultiplier * wNormal;
  112.     wBumpedNormal = normalMultiplier * wBumpedNormal;
  113.  
  114.     // Compute the viewer's reflection direction.
  115.     //
  116.     float3 wReflectDir = reflect(-wViewDir, wBumpedNormal);
  117.     
  118.  
  119. #if defined(REFLECT_CUBE_LOOKUP)
  120.  
  121.     // Transform the reflection vector from world space to
  122.     // cube space. Ideally, we'd take the full cube placement
  123.     // information into account, but since this is quite
  124.     // complicated, we use the traditional OpenGL-shortcut of 
  125.     // only applying a rotation.
  126.     //
  127.     float3 cReflectDir;
  128.     cReflectDir.x = dot(wReflectDir, worldToCubeRotationMatrix0);
  129.     cReflectDir.y = dot(wReflectDir, worldToCubeRotationMatrix1);
  130.     cReflectDir.z = dot(wReflectDir, worldToCubeRotationMatrix2);
  131.     float3 reflectedColor = f3texCUBE(reflectedColTex, cReflectDir);
  132.  
  133. #elif defined(REFLECT_SPHERE_LOOKUP)
  134.  
  135.     // This calculation is directly taken from the OpenGL spec's sphere
  136.     // mapping section.
  137.     //
  138.     float x = wReflectDir.x;
  139.     float y = wReflectDir.y;
  140.     float z = wReflectDir.z + 1;
  141.     float m = 2.0 * sqrt(x * x + y * y + z * z);
  142.  
  143.     float2 sphereUv = wReflectDir.xy / m + 0.5;
  144.     float3 reflectedColor = f3tex2D(reflectedColTex, sphereUv);
  145.  
  146. #else
  147.  
  148.     // Set the reflected color to black.
  149.     float3 reflectedColor = float3(0, 0, 0);
  150.  
  151. #endif
  152.  
  153.     // Apply the reflectivity texture matrix to the corresponding texture 
  154.     // coordinates, then fetch the appropriate texel.
  155.     //
  156.     float2 placedReflectivityTexUv;
  157.     float4 reflectivityTexUv = float4(IN.reflectivityTexUv.xy, 0.0, 1.0);
  158.     placedReflectivityTexUv.x = dot(reflectivityTexMatrix0, reflectivityTexUv);
  159.     placedReflectivityTexUv.y = dot(reflectivityTexMatrix1, reflectivityTexUv);
  160.     float reflectivity = f4tex2D(reflectivityTex, placedReflectivityTexUv).r;
  161.  
  162.     // Apply the incandescence texture matrix to the corresponding texture 
  163.     // coordinates, then fetch the appropriate texel.
  164.     //
  165.     float2 placedIncanTexUv;
  166.     float4 incanTexUv = float4(IN.incanTexUv.xy, 0.0, 1.0);
  167.     placedIncanTexUv.x = dot(incanTexMatrix0, incanTexUv);
  168.     placedIncanTexUv.y = dot(incanTexMatrix1, incanTexUv);
  169.     float3 incandescence = f3tex2D(incanTex, placedIncanTexUv);
  170.  
  171.     float3 refractedColor = 0;
  172.  
  173. #if defined(REFRACT_CUBE_LOOKUP)
  174.  
  175.     float4 opacityColor;
  176.  
  177. #if defined(OPACITY_IN_COLOR_ALPHA)
  178.     // The opacity is encoded in the base color texture's alpha.
  179.     // (NOTE: the cpp code is expected to bind the color_tex texture
  180.     // to the transpTex sampler2D.)
  181.     //
  182.     opacityColor = fetchedTranspColor.aaaa;
  183.  
  184. #else    // TRANSP_IN_TRANSP_RGB
  185.     // Apply the transparency texture matrix to the corresponding texture 
  186.     // coordinates, then fetch the appropriate texel.
  187.     //
  188.     float2 placedTranspTexUv;
  189.     float4 transpTexUv = float4(IN.transpTexUv.xy, 0.0, 1.0);
  190.     placedTranspTexUv.x = dot(transpTexMatrix0, transpTexUv);
  191.     placedTranspTexUv.y = dot(transpTexMatrix1, transpTexUv);
  192.     float4 fetchedTranspColor = f4tex2D(transpTex, placedTranspTexUv);
  193.  
  194.     // The transparency color is encoded in the transparency texture's RGB,
  195.     // and the opacity is stored in the transparency texture's alpha.
  196.     //
  197.     opacityColor.rgb = 1-fetchedTranspColor.rgb;
  198.     opacityColor.a = fetchedTranspColor.a;
  199. #endif // 
  200.     
  201.     // Compute the refracted color.
  202.     float3 cViewDir;
  203.     cViewDir.x = dot(-wViewDir, worldToCubeRotationMatrix0);
  204.     cViewDir.y = dot(-wViewDir, worldToCubeRotationMatrix1);
  205.     cViewDir.z = dot(-wViewDir, worldToCubeRotationMatrix2);
  206.  
  207.     float3 cBumpedNormal;
  208.     cBumpedNormal.x = dot(wBumpedNormal, worldToCubeRotationMatrix0);
  209.     cBumpedNormal.y = dot(wBumpedNormal, worldToCubeRotationMatrix1);
  210.     cBumpedNormal.z = dot(wBumpedNormal, worldToCubeRotationMatrix2);
  211.  
  212.     // TODO: implement and test chromatic abherration.
  213.     //
  214.     float3 cRefractDir = refract(cViewDir, cBumpedNormal, refractiveIndices.r);
  215.     refractedColor = f3texCUBE(reflectedColTex, cRefractDir);
  216.  
  217.     // Modulate the refracted color by the transparency.
  218.     // (ie: a highly transparent surface will translate into a highly
  219.     // refractive surface.)
  220.     //
  221.     refractedColor.rgb = refractedColor * (1-opacityColor.rgb);
  222.  
  223. #endif // REFRACT_CUBE_LOOKUP
  224.  
  225.     float4 finalColor;
  226.     finalColor.rgb = reflectivity * reflectedColor + incandescence + refractedColor;
  227.     finalColor.a = 1;
  228.  
  229.     return finalColor;
  230. }
  231.